﻿//#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>
//#include<math.h>
//
//#define min  100
//#define max  200
//int main() 
//{
//	//写一个代码：打印100~200之间的素数
//	// 思路1. 只要2到M之间不能被整除就行。遍历2~M就行
//	// 思路2. 只要在[2，i/ 2]之间i不能被整除，则为素数
//	// 思路3. 只要2到开根号M没有整除M的数就行，少遍历一半的数。
//	int count = 0;
//	for (int i = min; i <= max; i++)
//	{
//		int n = 0;
//		 int k = (int)sqrt(i);  // 开根号是接收double类型的数
//		for (n = 2; n <= k; n++)
//		{
//			if (i % n == 0)  // 非素数
//				break;
//		}
//		if (n > k)
//		{
//			count++;
//			printf("%d ", i);
//		}
//	}
//	printf("\n");
//	printf("共%d", count);
//
//	return 0;
//}



//#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>
//#include<math.h>
//
//#define min 1000
//#define max 2000
////打印1000年到2000年之间的闰年
////打印闰年
//// 1. 润年：  1. 普通闰年 4的倍数， 非100的倍数
//            //2. 400的倍数
//
//int main()
//{
//	int count = 0;
//	for (int i = min; i <= max; i++)
//	{
//		if (((i % 4 == 0) && (i % 100 != 0)) || (i % 400 == 0))
//		{
//			printf(" %d", i);
//			count++;
//		}
//	}
//	printf("共%d", count);
//	return 0;
//}



//#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>
//#include<math.h>
//
//#define max 100
//void text1();
//int main()
//{
//	text();
//	return 0;
//}
//
//void text()
//{
//	//计算1 / 1 - 1 / 2 + 1 / 3 - 1 / 4 + 1 / 5 …… + 1 / 99 - 1 / 100 的值，打印出结果
//	double k = 0, z = 0;
//	for (int i = 1; i <= max; i++)
//	{
//		if (i % 2 == 0)
//		{
//			k += 1.0 / i;
//		}
//		else
//		{
//			z += 1.0 / i;
//		}
//	}
//	printf("%.7lf", z - k);
//}
//
//
//void text1()
//{
//	text();
//}

//#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>
//#include<math.h>
//
//int text(int , int);
//int main() 
//{
//	int x = 20;
//	int y = 10;
//	int z = text(x, y);
//	printf("%d", z);
//	return 0;
//}
//
//int text(int x, int y)
//{
//	return x + y;
//}


//#define _CRT_SECURE_NO_WARNINGS 1
//#include<stdio.h>
//#include<math.h>
//int main()
//{
//	int i = 0;
//	int sum = 0;//保存最终结果
//	int n = 3;
//	/*scanf("%d", &n);*/
//	for (i = 1; i <= n; i++)
//	{
//		int ret = 1;
//		for (int j = 1; j <= i; j++)
//		{
//			ret *= j;
//		}
//		sum += ret;
//	}
//	printf("%d\n", sum);
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	int i = 0;
//	int arr[10] = {0, 1, 2, 3 ,4 ,5 ,6, 7, 8, 9};
//	for (i = 0; i <= 12; i++)
//	{
//		arr[i] = 0;
//		printf("hehe ");
//	}
//	return 0;
//}

// 实现一个strlen
// 实现strcpy
//#include <stdio.h>
//
//void Strlen(char* a);
//void Strcpy(char* a, const char* b);
//
//
//int main()
//{
//	char a[10] = "china";
//	char b[10] = "Bejing";
//	Strlen(a, b);
//	Strcpy(a, b);
//	return 0;
//}
//
//void Strlen(char* a)
//{
//	int sum = 0;
//	while (*a++)
//		sum++;
//	printf("个数%d\n", sum);
//}
//
//void Strcpy(char* a, const char* b)
//{
//	char* room = a;
//	while (*a++ = *b++);
//	printf("%s\n", room);
//}


//#include<stdio.h>
//
//int main()
//{
//	unsigned int a = -10;  // 可是有些坏家伙，明明已经用unsigned定义还用负数
//	// 存储方式发生了变化：计算机已经认为已经是正数，所以就不进行负数转码了
//	// 1000 0000 0000 0000 0000 0000 0000 0110  原码
//	// 1111 1111 1111 1111 1111 1111 1111 1010  补码
//	printf("%u\n", a);   // 打印无符号数，计算机已经把首位不当成符号位，即把补码当成原码输出。
//	printf("%d\n", a);   // 打印有符号位数，当成符号位输出，首位还是符号位判断。
//	return 0;
//}


// 输入一个整数数组，实现一个函数，来调整该数组中数字的顺序使得数组中所有的奇数位于数组的前半部分，
//所有偶数位于数组的后半部分。

//#include<stdio.h>
//#include<assert.h>
//#include<stdlib.h>
//
//#define size 10
//int* ReTink(int* a);
//
//int main()
//{
//	int a[size] = { 12, 2, 3, 4, 5, 6, 7, 8, 9,10 };
//	int* b = ReTink(a);
//	for (int i = 0; i < size; i++)
//	{
//		printf("%d ", *(b + i));
//	}
//	free(a);
//	return 0;
//}
//
//
//int* ReTink(int* a)
//{
//	assert(a);
//	int* b = (int*)malloc(sizeof(int) * size);
//	if (b == NULL)
//	{
//		printf("malloc fail\n");
//		exit(-1);
//	}
//	for (int i = 0, j = size - 1, k = 0; i < size; i++)
//	{
//		if (*(a + i) % 2)  // 奇数
//		{
//			b[k++] = *(a + i);
//		}
//		else
//		{   // 偶数
//			b[j--] = *(a + i);
//		}
//	}
//	return b;
//}

//#include<stdio.h>
//
//int main()
//{
//	unsigned int b = -10;
//	printf("%u\n", b);
//	printf("%d", b);
//
//	return 0;
//}

//#include<stdio.h>
//int main()
//{
//	int a = 1;
//	if (*(char *)&a)
//	{
//		printf("小端\n");
//	}
//	else
//	{
//		printf("大端\n");
//	}
//	return 0;
//}

//int main()
//{
//    int n = 9;
//    float* pFloat = (float*)&n;
//    printf("n的值为：%d\n", n);  //      结果： 9
//    // 整型补码  0000 0000 0000 0000 0000 0000 0000 1001
//    printf("*pFloat的值为：%f\n", *pFloat);//  0.000000
//    // 以浮点型存储视角来看
//    // 0 00000000 00000000000000000001001
//    //->  (-1)^(0) * 0.00000000000000000001001 * 2 *(-126)
//
//    *pFloat = 9.0;
//    // 9.0二进制 1001.0->  S = 0, E = 3, M = .001
//    // 所以其浮点数二进制为 0 10000010 00100000000000000000000  然后给 n 
//    printf("num的值为：%d\n", n);          //  1091567616
//    // 将n内的数据以有符号整型输出(说白了就是以整型输出法则输出数据)
//    // 所以就是这么大的数
//    printf("*pFloat的值为：%f\n", *pFloat);//  9.000000
//    // 数据本身是以浮点型存储，然后以浮点型方式取出，E = 130 - 127,M 的头添上个一
//    // (-1)^(0) * (1.001) * 2^(3) 所以结果为 9.000000(float类型默认保存小数点后6位)
//    return 0;
//}


//un char a = 200;
//0000 0000 0000 0000 0000 0000 1100 1000
//un char b = 100;
//0000 0000 0000 0000 0000 0000 0110 0100
//char              0010 1100  44

//// 杨辉三角
//#include<stdio.h>
///*
//1
//11
//121
//1331
//*/
//#define n 5
//int main() 
//{
//	int a[n][n];
//	for (int i = 0; i < n; i++)
//	{
//		for (int k = 0; k < i + 1; k++)
//		{
//			if (k == 0 || k == i)
//			{
//				a[i][k] = 1;
//			}
//			else
//			{
//				a[i][k] = a[i - 1][k] + a[i - 1][k - 1];
//			}
//			printf("%d ", a[i][k]);
//		}
//		printf("\n");
//	}
//	return 0;
//}


//日本某地发生了一件谋杀案，警察通过排查确定杀人凶手必为4个嫌疑犯的一个。
//以下为4个嫌疑犯的供词:
//A说：不是我。 
//B说：是C。    1 
//C说：是D。    0
//D说：C在胡说  1
//已知3个人说了真话，1个人说的是假话。
//现在请根据这些信息，写一个程序来确定到底谁是凶手。



//#include<stdio.h>
//int main()
//{
//	int killer = 0;
//	for (char i = 'a'; i <= 'd'; i++)
//	{
//		if ((killer = (i != 'a') + (i == 'c') + (i == 'd') + (i != 'd')) == 3)
//		{
//			printf("凶手是%c\n", i);
//			break;
//		}
//	}
//	return 0;
//}




//#include<stdio.h>
//int main()
//{
//	int a[3][5] = {{1,2, 3, 4,5},
//				   {6,7, 8, 9, 10},
//				   {11, 12, 13, 14,15}};
//	int(*p)[5] = a;
//	for (int i = 0; i < 3; i++)
//	{
//		for (int k = 0; k < 5; k++)
//		{
//			printf("%d ", *(*(p + i) + k));
//		}
//		printf("\n");
//	}
//	return 0;
//}


//#include<stdio.h>
//
//void text(int* a)
//{
//	;
//}
//int main()
//{
//	int a[2][3];
//	text(a);
//
//	return 0;
//}
//
//// 转移表
//#define _CRT_SECURE_NO_WARNINGS
//#include<stdio.h>
//
//#define n 5
//
//#include <stdio.h>
//int add(int a, int b)
//{
//	return a + b;
//}
//int sub(int a, int b)
//{
//	return a - b;
//}
//int mul(int a, int b)
//{
//	return a * b;
//}
//int div(int a, int b)
//{
//	return a / b;
//}
//
//int main()
//{
//	printf("----------------------------\n");
//	printf("--- 1. add  2. sub ---------\n");
//	printf("--- 3. mul  4. div ---------\n");
//	printf("-----  0. exit  ------------\n");
//	printf("----------------------------\n");
//	int (*app[])(int, int) = { 0, add, sub, mul, div };
//	int(*(*p)[5])(int, int) = &app;
//	do
//	{
//		int input = 0;
//		printf("请输入选择功能\n");
//		scanf("%d", &input);
//		if (input == 0)
//		{
//			printf("终止程序\n");
//			break;
//		}
//		else if (input > 0 && input < n)
//		{
//			printf("%d\n", (*p)[input](8, 4));
//		}
//		else
//		{
//			printf("输入有误\n");
//			break;
//		}
//		printf("请输入选择功能\n");
//	} while (1);
//
//	return 0;
//}

//有一个数字矩阵，矩阵的每行从左到右是递增的，矩阵从上到下是递增的，请编写程序在这样的矩阵中查找某个数字是否存在。
//要求：时间复杂度小于O(N);

//#include<stdio.h>
//int Find(int *a, int n,int max)
//{
//	// 直接用二分查找
//
//	int  min = 0;
//	while (min <= max)
//	{
//		int mid = (max + min) / 2;
//		if (a[mid] > n)
//		{
//			max = mid - 1;
//		}
//		else if (a[mid] < n)
//		{
//			min = mid + 1;
//		}
//		else
//			return 1;
//	}
//	return 0;
//}
//
//int main()
//{
//	int a[3][5] = { {1, 2, 3, 4, 5},
//					   {6, 7, 8, 9, 10},
//					   {11, 12, 13, 14,15} };
//	int n = 8;
//	int max = sizeof(a) / sizeof(a[0][0]) - 1;
//	if (Find(a, n, max))
//	{
//		printf("seccse, Find\n");
//	}
//	else
//	{
//		printf("not find\n");
//	}
//	return 0;
//}

//实现一个函数，可以左旋字符串中的k个字符。
//例如：
//ABCD左旋一个字符得到BCDA
//ABCD左旋两个字符得到CDAB


//#include<stdio.h>
//#define k 4
//void exchange(char* a, char* b, int Rn)
//{
//	for (int i = 0 ; i < k; i++)
//	{
//		int d = Rn % k;
//		b[i] = *(a + d);
//		Rn++;
//		printf("%c", b[i]);
//	}
//	printf("\n");
//}
//
//int main()
//{
//	char* a = "ABCD";
//	char b[k];
//	int Rn = 1;
//	exchange(a, b, Rn);
//	return 0;
//}

//#define _CRT_SECURE_NO_WARNINGS
//
//#include <stdio.h>
//int add(int a, int b)
//{
//	return a + b;
//}
//int sub(int a, int b)
//{
//	return a - b;
//}
//int mul(int a, int b)
//{
//	return a * b;
//}
//int div(int a, int b)
//{
//	return a / b;
//}
//
//void prf(int (*p)(int , int ))
//{
//	int x, y;
//	printf("输入操作数：");
//	scanf("%d %d", &x, &y);
//	printf("ret = %d\n", p(x,y));
//}
//
//
//
//int main()
//{
//	int x, y;
//	int input = 1;
//	int ret = 0;
//	do
//	{
//		printf("*************************\n");
//		printf(" 1:add           2:sub \n");
//		printf(" 3:mul           4:div \n");
//		printf("*************************\n");
//		printf("请选择：");
//		scanf("%d", &input);
//		switch (input)
//		{
//		case 1:
//			prf(add);
//			break;
//		case 2:
//			prf(sub);
//			break;
//		case 3:
//			prf(mul);
//			break;
//		case 4:
//			prf(div);
//			break;
//		case 0:
//			printf("退出程序\n");
//			break;
//		default:
//			printf("选择错误\n");
//			break;
//		}
//	} while (input);
//
//	return 0;
//}

//#include <stdio.h>
//#include<stdlib.h>
//
//// 自定义函数
//int swap(const void* x, const void* y)
//{
//	//这里对数字大小升序
//	return (*(int*)x - *(int*)y); // 计算机不知道x, y数据类型，因此强制转化
//}
//int main()
//{
//	int a[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
//	int size = sizeof(a) / sizeof(a[0]);
//	qsort(a, size, sizeof(a[0]), swap);
//	for (int i = 0; i < size; i++)
//	{
//		printf("%d ", a[i]);
//	}
//	return 0;
//}



//#include<stdlib.h>
//#include<stdio.h>
//#include<string.h>
//
//typedef struct Data {
//	char* name;
//	int age;
//	int score;
//	char class;
//}Da;
//
//// 字符串
//int rank_name(const void* x, const void* y) // 降序升序更改一下位置即可
//{
//	return strcmp( ((Da*)x)->name, ((Da*)x)->name );
//}
//
//// 整型
//int rank_age(const void* x, const void* y) // 降序升序更改一下位置即可
//{
//	return (((Da*)x)->age - ((Da*)y)->age);
//}
//
//// 字符型
//int rank_class(const void* x, const void* y)
//{
//	return (((Da*)x)->class - ((Da*)y)->class);
//}
//
//
//
//int main()
//{
//	Da b[3] = { {"ahuang", 20, 90, 'A'}, {"linei", 34, 76,'B'}, {"liujie", 24, 89, 'C'}};
//	int size = sizeof(b) / sizeof(b[0]);
//	qsort(b, size, sizeof(b[0]), rank_age);
//		for (int i = 0; i < size; i++)
//		{
//			printf("name %s ", (b + i)->name);
//			printf("age %d ", (b + i)->age);
//			printf("score %d ", (b + i)->score);
//			printf("class %c ", (b + i)->class);
//			printf("\n");
//		}
//	return 0;
//}

//
//#include<stdlib.h>
//#include<stdio.h>
//#include<string.h>
//int int_cmp(const void* p1, const void* p2)
//{
//	return *(int*)p1 - *(int*)p2;
//}
//
//void _swap(void* p1, void* p2, int size)
//{
//	int i = 0;
//	for (i = 0; i < size; i++)
//	{   // 将数据一个一个字节的交换，保证任何数据都能替换
//		char tmp = *((char*)p1 + i);
//		*((char*)p1 + i) = *((char*)p2 + i);
//		*((char*)p2 + i) = tmp;
//	}
//}
//void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < count - 1; i++)
//	{
//		for (j = 0; j < count - i - 1; j++)
//		{
//			if (cmp( (char*)base + j*size , (char*)base + (j + 1)* size) > 0)
//			{
//				_swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
//			}
//		}
//	}
//}
//int main()
//{
//	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
//	int i = 0;
//	bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), int_cmp);
//	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	printf("\n");
//	return 0;
//}


//写一个函数，判断一个字符串是否为另外一个字符串旋转之后的字符串。
//例如：给定s1 = AABCD和s2 = BCDAA，返回1
//给定s1 = abcd和s2 = ACBD，返回0.
//AABCD左旋一个字符得到ABCDA
//AABCD左旋两个字符得到BCDAA
//AABCD右旋一个字符得到DAABC


//#include<stdio.h>
//#include<string.h>

//int check(char* p1, char* p2, int size)
//{
//	int time = size;
//	int i = 0, j = 0;
//	int door = 2;
//	// 对齐
//	while (time)
//	{
//		if (*(p1 + i) == *(p2 + 0))
//		{
//			break;
//		}
//		i++;
//		time--;
//	}
//	if (time == 0)
//	{
//		return 0;
//	}
//	
//	// 开始判断
//	time = size + 1;
//	while (time--)
//	{
//		// 取模
//		i %= size,j %= size;
//		if (*(p1 + i) == *(p2 + j))
//		{
//			i++;
//			door = 2;
//		}
//		else if ( *(p1 + i) != *(p2 + j))
//		{
//			door--;
//			if (door == 0)
//				return 0;
//			j++;
//		}
//	}
//	return 1;
//}
//int main()
//{
//	char* a = "eabcd";
//	char* b = "deabc";
//	int size = strlen(a);
//	printf("%s\n", a);
//	printf("%s\n", b);
//	printf("%d ", check(a, b, size));
//	return 0;
//}
//#define _CRT_SECURE_NO_WARNINGS
//#include<stdio.h>
//#include<string.h>
//
//int check_str(const char* a, const char* b)
//{
//	char arr[128] = { 0 }; // 存放双倍字符串
//	strcpy(arr, a);  // 拷贝一遍
//	strcat(arr, a);  // 再拼接一份
//	return strstr(arr, b) != NULL; //不为空就是找到子链
//}
//int main()
//{  
//	char* a = "eabcd";
//	char* b = "deabc";
//	int size = strlen(a);
//	printf("%s\n", a);
//	printf("%s\n", b);
//	printf("===%d=== ", check_str(a, b));
//	return 0;
//}


